/**
 * 串的顺序存储结构
 */
public class string {
    private int maxSize=10; //串中字符数组的初始长度
    private char[] chars;   //存储元素的数组对象
    private int length;     //保存串的当前长度
    /**
     * 构造一个空串
     */
    public string()
    {
        this.chars=new char[maxSize];
        this.length=0;
    }

    /**
     * 构造一个能保存n个字符的串
     */
    public string(int n)
    {
        this.maxSize=n;
        this.chars=new char[n];
        this.length=0;
    }

    /**
     * 复制串
     * @param t
     */
    public void copy(string t)
    {
        //若当前串无法容纳串t的内容，将扩充当前的容量
        if (this.maxSize<t.maxSize)
        {
            this.maxSize=t.maxSize;
            this.chars = new char[this.maxSize];
        }
        this.length=0;
        for (int i=0; i<t.getLength(); i++)
        {
            this.chars[i]=t.chars[i];
            this.length++;
        }
    }

    /**
     * 判空
     */
    public boolean isEmpty()
    {
        return length==0;
    }

    /**
     * 串比较
     * 若当前串等于串t,则返回值=0；若当前串>串t，则返回值1；若当前串<串t，则返回-1
     */
    public int compare(string t)
    {
        int i=0;
        while (this.chars[i]==t.chars[i] && i<this.length && i<t.getLength())
        {
            i++;
        }
        if (i==this.length && i==t.length)
            return 0;
        else if (i==t.getLength() && i<this.length)
            return 1;
        else
            return -1;
    }
    /*获取长度*/
    public int getLength()
    {
        return length;
    }
    /*销毁*/
    public void clear()
    {
        length=0;
    }
    /*串连接*/
    public void concat(string t)
    {
        //若当前串无法容纳串t的内容，则先扩充当前串的容量
        if (this.maxSize < this.length+t.getLength())
        {
            //将当前串中的内容暂存到数组a中
            char[] a = new char[this.length];
            for (int i=0; i<this.length; i++)
            {
                a[i]=this.chars[i];
            }
            //扩展当前串的容量
            this.maxSize = this.length + this.getLength();
            this.chars = new char[this.maxSize];
            //恢复当前串的原始状态
            for (int i =0; i<a.length; i++)
            {
                this.chars[i]=a[i];
            }
        }
        //将串t的内容添加到当前串的尾部，实现连接操作
        for (int i = 0; i<t.getLength(); i++)
        {
            this.chars[this.length]=t.chars[i];
            this.length++;
        }

    }
    /**
     *求子串
     * 从当前串中的第pos个字符开始连续提取len个字符而得到一个字符串
     */
    public string subString(int pos,int len)
    {
        //若提取的子串的起始位置与提取的子串的长度之和超过了当前串的长度，则操作非常并返回空串对象
        if (pos+len>=this.length)
            return null;
        //获取子串并返回
        string a = new string(len);
        for (int i=0; i<len; i++)
        {
            a.chars[i] = this.chars[pos+i];
            a.length++;
        }
        return a;
    }

    /**
     * 从当前串中的第pos个字符开始直到最后一个字符全部提取出来，得到一个子
     */
    public string subString(int pos)
    {
        //若提取的子串的起始位置与提取的子串的长度之和超过了当前串的长度，则操作非常并返回空串对象
        if (pos>=this.length)
            return null;
        //获取子串并返回
        string a = new string(this.length-pos);
        for (int i=0; i<this.length-pos; i++)
        {
            a.chars[i] = this.chars[pos+i];
            a.length++;
        }
        return a;
    }
    /*返回字符串t在当前串中首次出现的位置，若不存在，返回-1*/
    public int lastIndex(string t)
    {
        //若字符串大于当前字符串的长度返回-1
        if (t.getLength()>this.getLength())
            return -1;
        for (int i = 0; i < this.getLength(); i++)
        {
            for (int j = 0; j < t.getLength(); j++)
            {
                if (this.chars[i+j] != t.chars[j])
                {
                    break;
                }
                if (j==t.getLength()-1 && this.chars[i]== t.chars[j]){
                    return i;
                }
            }
        }
        return -1;
    }
    /**在当前串中用串v替换所有与串t相等的子串，并返回替换的次数*/
    public int replace(string t,string v)
    {
        //若字符串大于当前字符串的长度返回0
        if (t.getLength()>this.getLength())
            return 0;
        int num = 0;
        for (int i = 0; i < t.getLength(); i++)
        {
            for (int j = 0; j < v.getLength(); j++)
            {
                if (t.chars[i+j] != v.chars[j])
                {
                    break;
                }
                if (j==t.getLength()-1 && t.chars[i]== v.chars[j]){
                    num++;
                }
            }
        }
        return num;
    }
    /** 将串t插入到当前串的第pos个位置上*/
    public boolean insert(string t,int pos)
    {
        //若当前串无法容纳串t的内容，将扩充当前的容量
        if (this.maxSize<t.maxSize)
        {
            this.maxSize+=t.maxSize;
            this.chars = new char[this.maxSize];
        }
        this.length=0;
        for (int i=0; i<t.getLength(); i++)
        {
            this.chars[pos+i+t.length] = this.chars[pos+i];
            this.chars[pos+i]=t.chars[i];
            this.length++;
        }
        return true;
    }
    /** 删除当前串从第pos个字符开始的连续len个字符*/
    public boolean delete(int pos,int n)
    {
        if (this.maxSize<n)
        {
            return false;
        }
        for (int i = pos; i<this.length-n; i++)
        {
            this.chars[i] = this.chars[i+n];
            this.length--;
        }
        return true;
    }

    /**
     * 在当前串中删除所有与串t相等的子串，并返回删除的次数
     */
    public int remove(string t)
    {
        if (this.length<t.length)
        {
            return 0;
        }
        int num = 0,k=0;
        boolean flag = true;
        string p = new string(this.length);
        for(int i =0; i<this.length; i++){
            for (int j=0;j<t.getLength();j++){
                if (this.chars[i+j]!=t.chars[j]){
                    flag = true;
                    break;
                }
                if (j==(t.getLength()-1)){
                    flag = false;
                    i+=j;
                    num++;
                }
            }
            if (flag){
                p.chars[k]=this.chars[i];
            }
        }
        this.copy(p);
        return num;
    }

    /**
     * 将当前串的所有字母全部转换为大写字母
     * 字符串变字符数组，大转小，字符值加32，小转大，字符值减32 。大写字母范围是：65-90，小写字母范围是：97-122。
     * @return
     */
    public string toUpperCase()
    {
        if (this.length ==0){
            return new string();
        }
        string p = new string(this.length);
        final int len = this.length;
        for (int i =0;i<len;i++){
            if (this.chars[i]>=97 && this.chars[i]<=122){
                p.chars[i] =(char)(this.chars[i]-32);
            }else {
                p.chars[i] = this.chars[i];
            }
        }
        return p;
    }

    /**
     * 将当前串的所有字母全部转换为小写字母
     * @return
     */
    public string toLowerCase()
    {
        if (this.length ==0){
            return new string();
        }
        string p = new string(this.length);
        final int len = this.length;
        for (int i =0;i<len;i++){
            if (this.chars[i]>=97 && this.chars[i]<=122){
                p.chars[i] =(char)(this.chars[i]-32);
            }else {
                p.chars[i] = this.chars[i];
            }
        }
        return p;
    }
}
